Python मधील ईमेल पॅकेजवर प्रभुत्व मिळवणे: MIME संदेश निर्मिती आणि मजबूत पार्सिंगची कला

ईमेल जागतिक संवादाचा एक आधारस्तंभ राहिला आहे, जो वैयक्तिक पत्रव्यवहार, व्यावसायिक कामकाज आणि स्वयंचलित सिस्टम नोटिफिकेशन्ससाठी अपरिहार्य आहे. प्रत्येक रिच-टेक्स्ट ईमेल, प्रत्येक संलग्नक आणि प्रत्येक काळजीपूर्वक फॉरमॅट केलेल्या स्वाक्षरीच्या मागे मल्टीपर्पज इंटरनेट मेल एक्सटेन्शन्स (MIME) ची जटिलता आहे. डेव्हलपर्ससाठी, विशेषतः पायथनवर काम करणाऱ्यांसाठी, हे MIME संदेश प्रोग्रामेटिकरित्या कसे तयार करायचे आणि पार्स करायचे हे शिकणे एक महत्त्वपूर्ण कौशल्य आहे.

Python चे अंगभूत email पॅकेज ईमेल संदेश हाताळण्यासाठी एक मजबूत आणि सर्वसमावेशक फ्रेमवर्क प्रदान करते. हे केवळ साधे मजकूर पाठवण्यासाठी नाही; हे MIME च्या क्लिष्ट तपशीलांना अमूर्त करण्यासाठी डिझाइन केलेले आहे, ज्यामुळे तुम्हाला उत्कृष्ट अचूकतेने अत्याधुनिक ईमेल तयार करता येतात आणि येणाऱ्या ईमेलमधून विशिष्ट डेटा काढता येतो. ही मार्गदर्शिका तुम्हाला या पॅकेजच्या दोन मुख्य पैलूंमध्ये सखोल माहिती देईल: पाठवण्यासाठी MIME संदेश तयार करणे आणि डेटा काढण्यासाठी ते पार्स करणे, सर्वोत्तम पद्धतींवर जागतिक दृष्टिकोन प्रदान करेल.

निर्मिती आणि पार्सिंग दोन्ही समजून घेणे महत्त्वपूर्ण आहे. जेव्हा तुम्ही संदेश तयार करता, तेव्हा तुम्ही दुसऱ्या सिस्टमसाठी त्याचा स्ट्रक्चर आणि सामग्री परिभाषित करत असता. जेव्हा तुम्ही पार्स करता, तेव्हा तुम्ही दुसऱ्या सिस्टमने परिभाषित केलेले स्ट्रक्चर आणि सामग्रीचा अर्थ लावत असता. एकाचे सखोल ज्ञान दुसऱ्यावर प्रभुत्व मिळविण्यात खूप मदत करते, ज्यामुळे अधिक लवचिक आणि इंटरऑपरेबल ईमेल ऍप्लिकेशन्स तयार होतात.

MIME समजून घेणे: आधुनिक ईमेलचा कणा

पायथन विशिष्ट तपशीलांमध्ये जाण्यापूर्वी, MIME काय आहे आणि ते इतके महत्त्वाचे का आहे हे समजून घेणे आवश्यक आहे. सुरुवातीला, ईमेल संदेश केवळ साध्या मजकुरापर्यंत (7-बिट ASCII वर्ण) मर्यादित होते. 1990 च्या दशकाच्या सुरुवातीला सादर केलेल्या MIME ने ईमेलच्या क्षमतांचा विस्तार केला:

• Non-ASCII वर्ण: अरबी, चीनी, रशियन किंवा ASCII सेटच्या बाहेरील वर्ण वापरणाऱ्या कोणत्याही भाषेतील मजकुराला परवानगी देते.
• संलग्नके: दस्तऐवज, प्रतिमा, ऑडिओ आणि व्हिडिओ सारख्या फायली पाठवणे.
• रिच टेक्स्ट फॉरमॅटिंग: बोल्डिंग, इटॅलिक्स, रंग आणि लेआउटसह HTML ईमेल.
• एकाधिक भाग: एकाच ईमेलमध्ये साधे मजकूर, HTML आणि संलग्नके एकत्र करणे.

MIME हे ईमेल संदेशात विशिष्ट हेडर जोडून आणि त्याच्या बॉडीला विविध "भागांमध्ये" (parts) संरचित करून साध्य करते. तुम्हाला आढळणारे मुख्य MIME हेडरमध्ये हे समाविष्ट आहेत:

• Content-Type: भागातील डेटाचा प्रकार निर्दिष्ट करते (उदा. text/plain, text/html, image/jpeg, application/pdf, multipart/alternative). यात अनेकदा charset पॅरामीटर देखील समाविष्ट असतो (उदा. charset=utf-8).
• Content-Transfer-Encoding: ईमेल क्लायंटने सामग्री कशी डीकोड करावी हे दर्शवते (उदा. बायनरी डेटासाठी base64, बहुतेक मजकूर आणि काही गैर-ASCII वर्णांसाठी quoted-printable).
• Content-Disposition: प्राप्तकर्त्याच्या ईमेल क्लायंटने भाग कसा प्रदर्शित करावा हे सुचवते (उदा. संदेश बॉडीमध्ये प्रदर्शित करण्यासाठी inline, सेव्ह करण्यासाठी फाइलसाठी attachment).

Python email पॅकेज: सखोल अभ्यास

Python चे email पॅकेज हे प्रोग्रामेटिकरित्या ईमेल संदेश तयार करण्यासाठी, पार्स करण्यासाठी आणि सुधारित करण्यासाठी डिझाइन केलेले एक सर्वसमावेशक लायब्ररी आहे. हे Message ऑब्जेक्ट्सच्या संकल्पनेवर आधारित आहे, जे ईमेलची रचना दर्शवतात.

पॅकेजमधील मुख्य मॉड्यूल्समध्ये हे समाविष्ट आहेत:

• email.message: मुख्य EmailMessage क्लास समाविष्ट आहे, जी ईमेल संदेश तयार करण्यासाठी आणि हाताळण्यासाठी प्राथमिक इंटरफेस आहे. ही एक अत्यंत लवचिक क्लास आहे जी MIME तपशील आपोआप हाताळते.
• email.mime: MIME स्ट्रक्चरवर अधिक स्पष्ट नियंत्रण प्रदान करणाऱ्या लेगसी क्लासेस (उदा. MIMEText, MIMEMultipart) प्रदान करते. नवीन कोडसाठी EmailMessage सामान्यतः त्याच्या साधेपणामुळे प्राधान्य दिले जात असले तरी, या क्लासेसना समजून घेणे फायदेशीर ठरू शकते.
• email.parser: कच्च्या ईमेल डेटाला (बाइट्स किंवा स्ट्रिंग्स) EmailMessage ऑब्जेक्ट्समध्ये रूपांतरित करण्यासाठी BytesParser आणि Parser सारखे क्लासेस ऑफर करते.
• email.policy: ईमेल संदेश कसे तयार केले जातात आणि पार्स केले जातात हे नियंत्रित करणारी पॉलिसी परिभाषित करते, जी हेडर एन्कोडिंग, लाइन एंडिंग आणि एरर हँडलिंगवर परिणाम करते.

बहुतेक आधुनिक वापरांसाठी, आपण निर्मिती आणि पार्स केलेल्या संदेश ऑब्जेक्ट या दोन्हीसाठी प्रामुख्याने email.message.EmailMessage क्लासशी संवाद साधाल. त्याच्या पद्धतींनी लेगसी email.mime क्लासेससह अधिक विस्तृत प्रक्रियेला खूप सोपे केले आहे.

MIME संदेश निर्मिती: अचूकतेने ईमेल तयार करणे

ईमेल तयार करण्यामध्ये विविध घटक (मजकूर, HTML, संलग्नके) एका वैध MIME स्ट्रक्चरमध्ये एकत्र करणे समाविष्ट आहे. EmailMessage क्लास या प्रक्रियेला लक्षणीयरीत्या सुलभ करते.

साधे मजकूर ईमेल

सर्वात सोपा ईमेल साध्या मजकुराचा असतो. तुम्ही तो तयार करू शकता आणि मूलभूत हेडर सहजपणे सेट करू शकता:

from email.message import EmailMessage

msg = EmailMessage()
msg['Subject'] = 'Greetings from Python'
msg['From'] = 'sender@example.com'
msg['To'] = 'recipient@example.com'
msg.set_content('Hello, this is a plain text email sent from Python.\n\nBest regards,\nYour Python Script')

print(msg.as_string())

स्पष्टीकरण:

• EmailMessage() एक रिक्त संदेश ऑब्जेक्ट तयार करते.
• डिक्शनरी-सारखे ऍक्सेस (msg['Subject'] = ...) सामान्य हेडर सेट करते.
• set_content() ईमेलची प्राथमिक सामग्री जोडते. डीफॉल्टनुसार, हे Content-Type: text/plain; charset="utf-8" चा अंदाज लावते.
• as_string() संदेश SMTP द्वारे पाठवण्यासाठी किंवा फाइलमध्ये सेव्ह करण्यासाठी योग्य अशा स्ट्रिंग फॉरमॅटमध्ये सीरिअलाइज करते.

HTML सामग्री जोडणे

HTML ईमेल पाठवण्यासाठी, तुम्ही set_content() कॉल करताना सामग्रीचा प्रकार निर्दिष्ट करता. ज्या प्राप्तकर्त्यांचे ईमेल क्लायंट HTML रेंडर करत नाहीत किंवा ऍक्सेसिबिलिटी कारणास्तव, साधा मजकूर पर्याय प्रदान करणे चांगली पद्धत आहे.

from email.message import EmailMessage

msg = EmailMessage()
msg['Subject'] = 'Your HTML Newsletter'
msg['From'] = 'newsletter@example.com'
msg['To'] = 'subscriber@example.com'

html_content = """
<html>
    <head></head>
    <body>
        <h1>Welcome to Our Global Update!</h1>
        <p>Dear Subscriber,</p>
        <p>This is your <strong>latest update</strong> from around the world.</p>
        <p>Visit our <a href="http://www.example.com">website</a> for more.</p>
        <p>Best regards,<br>The Team</p>
    </body>
</html>
"""

# HTML आवृत्ती जोडा
msg.add_alternative(html_content, subtype='html')

# साध्या मजकुराचा फॉलबॅक जोडा
plain_text_content = (
    "Welcome to Our Global Update!\n\n"
    "Dear Subscriber,\n\n"
    "This is your latest update from around the world.\n"
    "Visit our website for more: http://www.example.com\n\n"
    "Best regards,\nThe Team"
)
msg.add_alternative(plain_text_content, subtype='plain')

print(msg.as_string())

स्पष्टीकरण:

• add_alternative() चा वापर *समान* सामग्रीचे वेगवेगळे प्रतिनिधित्व जोडण्यासाठी केला जातो. ईमेल क्लायंट त्याला हाताळता येण्याजोगा "सर्वोत्तम" पर्याय प्रदर्शित करेल (सामान्यतः HTML).
• हे आपोआप multipart/alternative MIME रचना तयार करते.

संलग्नके हाताळणे

add_attachment() वापरून फाइल्स जोडणे सोपे आहे. तुम्ही कोणत्याही प्रकारची फाइल संलग्न करू शकता आणि पॅकेज योग्य MIME प्रकार आणि एन्कोडिंग (सामान्यतः base64) हाताळते.

from email.message import EmailMessage
from pathlib import Path

# प्रात्यक्षिकासाठी डमी फाइल्स तयार करा
Path('report.pdf').write_bytes(b'%PDF-1.4\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Count 0>>endobj\nxref\n0 3\n0000000000 65535 f\n0000000009 00000 n\n0000000052 00000 n\ntrailer<</Size 3/Root 1 0 R>>startxref\n104\n%%EOF') # एक अगदी मूलभूत, अवैध PDF प्लेसहोल्डर
Path('logo.png').write_bytes(b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\x99c`\x00\x00\x00\x02\x00\x01\xe2!\x00\xa0\x00\x00\x00\x00IEND\xaeB`\x82') # 1x1 पारदर्शक PNG प्लेसहोल्डर

msg = EmailMessage()
msg['Subject'] = 'Important Document and Image'
msg['From'] = 'sender@example.com'
msg['To'] = 'recipient@example.com'
msg.set_content('Please find the attached report and company logo.')

# PDF फाइल संलग्न करा
with open('report.pdf', 'rb') as f:
    file_data = f.read()
    msg.add_attachment(
        file_data,
        maintype='application',
        subtype='pdf',
        filename='Annual_Report_2024.pdf'
    )

# इमेज फाइल संलग्न करा
with open('logo.png', 'rb') as f:
    image_data = f.read()
    msg.add_attachment(
        image_data,
        maintype='image',
        subtype='png',
        filename='CompanyLogo.png'
    )

print(msg.as_string())

# डमी फाइल्स स्वच्छ करा
Path('report.pdf').unlink()
Path('logo.png').unlink()

स्पष्टीकरण:

• add_attachment() फाइलच्या कच्च्या बाइट्स (raw bytes) घेते.
• maintype आणि subtype MIME प्रकार निर्दिष्ट करतात (उदा. application/pdf, image/png). प्राप्तकर्त्याच्या ईमेल क्लायंटला संलग्नक योग्यरित्या ओळखण्यासाठी आणि हाताळण्यासाठी हे महत्त्वपूर्ण आहेत.
• filename हे प्राप्तकर्त्याद्वारे संलग्नक सेव्ह केले जाईल त्या नावासाठी वापरले जाते.
• हे आपोआप multipart/mixed रचना सेट करते.

मल्टीपार्ट संदेश तयार करणे

जेव्हा तुमच्याकडे HTML बॉडी, साध्या मजकुराचा फॉलबॅक आणि इनलाइन इमेज किंवा संबंधित फाइल्स असलेला संदेश असतो, तेव्हा तुम्हाला अधिक जटिल मल्टीपार्ट स्ट्रक्चरची आवश्यकता असते. EmailMessage क्लास add_related() आणि add_alternative() सह हे हुशारीने हाताळते.

HTML मध्ये थेट एम्बेड केलेली इमेज (एक "इनलाइन" इमेज) असलेली HTML ईमेल एक सामान्य परिस्थिती आहे. यासाठी multipart/related वापरले जाते.

from email.message import EmailMessage
from pathlib import Path

# प्रात्यक्षिकासाठी डमी इमेज फाइल तयार करा (1x1 पारदर्शक PNG)
Path('banner.png').write_bytes(b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\x99c`\x00\x00\x00\x02\x00\x01\xe2!\x00\xa0\x00\x00\x00\x00IEND\xaeB`\x82')

msg = EmailMessage()
msg['Subject'] = 'Inline Image Example'
msg['From'] = 'sender@example.com'
msg['To'] = 'recipient@example.com'

# साध्या मजकूर आवृत्ती (फॉलबॅक)
plain_text = 'Check out our amazing banner!\n\n[Image: Banner.png]\n\nVisit our site.'
msg.set_content(plain_text, subtype='plain') # सुरुवातीची साधी मजकूर सामग्री सेट करा

# HTML आवृत्ती (CID सह इनलाइन इमेजसाठी)
html_content = """
<html>
    <head></head>
    <body>
        <h1>Our Latest Offer!</h1>
        <p>Dear Customer,</p>
        <p>Don't miss out on our special global promotion:</p>
        <img src="cid:my-banner-image" alt="Promotion Banner">
        <p>Click <a href="http://www.example.com">here</a> to learn more.</p>
    </body>
</html>
"""

msg.add_alternative(html_content, subtype='html') # HTML पर्याय जोडा

# इनलाइन इमेज जोडा (संबंधित सामग्री)
with open('banner.png', 'rb') as img_file:
    image_data = img_file.read()
    msg.add_related(
        image_data,
        maintype='image',
        subtype='png',
        cid='my-banner-image' # हा CID HTML मधील 'src' शी जुळतो
    )

print(msg.as_string())

# डमी फाइल स्वच्छ करा
Path('banner.png').unlink()

स्पष्टीकरण:

• set_content() प्रारंभिक सामग्री (येथे, साधे मजकूर) स्थापित करते.
• add_alternative() HTML आवृत्ती जोडते, ज्यामुळे साध्या मजकूर आणि HTML भागांना समाविष्ट करणारी multipart/alternative रचना तयार होते.
• add_related() हे संदेशाच्या भागांशी "संबंधित" असलेल्या सामग्रीसाठी वापरले जाते, विशेषतः HTML मध्ये इनलाइन इमेज. हे cid (कंटेंट-आयडी) पॅरामीटर घेते, ज्याचा संदर्भ HTML <img src="cid:my-banner-image"> टॅगमध्ये दिला जातो.
• अंतिम रचना multipart/mixed (जर बाह्य संलग्नके असतील) असेल, ज्यात multipart/alternative भाग असेल, ज्यात multipart/related भाग असेल. multipart/related भागामध्ये HTML आणि इनलाइन इमेज असते. EmailMessage क्लास तुमच्यासाठी या नेस्टिंगची जटिलता हाताळते.

जागतिक पोहोचसाठी एन्कोडिंग आणि कॅरेक्टर सेट्स

आंतरराष्ट्रीय संवादासाठी, योग्य कॅरेक्टर एन्कोडिंग अत्यंत महत्त्वाचे आहे. email पॅकेज, डीफॉल्टनुसार, UTF-8 वापरण्याबद्दल अत्यंत निश्चित आहे, जे जगभरातील विविध कॅरेक्टर सेट्स हाताळण्यासाठी युनिव्हर्सल स्टँडर्ड आहे.

from email.message import EmailMessage

msg = EmailMessage()
msg['Subject'] = 'Global Characters: こんにちは, Привет, नमस्ते'
msg['From'] = 'global_sender@example.com'
msg['To'] = 'global_recipient@example.com'

# जपानी, रशियन आणि हिंदी वर्ण
content = "This message contains diverse global characters:\n"
content += "こんにちは (Japanese)\n"
content += "Привет (Russian)\n"
content += "नमस्ते (Hindi)\n\n"
content += "The 'email' package handles UTF-8 gracefully."

msg.set_content(content)

print(msg.as_string())

स्पष्टीकरण:

• जेव्हा set_content() ला पायथन स्ट्रिंग मिळते, तेव्हा ते आपोआप UTF-8 मध्ये एन्कोड करते आणि Content-Type: text/plain; charset="utf-8" हेडर सेट करते.
• जर सामग्रीला याची आवश्यकता असेल (उदा. अनेक गैर-ASCII वर्ण असतील), तर ते जुन्या ईमेल सिस्टमवर सुरक्षित प्रसारणासाठी Content-Transfer-Encoding: quoted-printable किंवा base64 लागू करू शकते. निवडलेल्या पॉलिसीनुसार पॅकेज हे आपोआप हाताळते.

सानुकूल हेडर आणि पॉलिसी

तुम्ही ईमेलमध्ये कोणताही सानुकूल हेडर जोडू शकता. पॉलिसी (email.policy मधून) संदेश कसे हाताळले जातात हे परिभाषित करतात, हेडर एन्कोडिंग, लाइन एंडिंग आणि एरर हँडलिंग सारख्या पैलूंवर परिणाम करतात. डीफॉल्ट पॉलिसी सामान्यतः चांगली असते, परंतु तुम्ही SMTP अनुपालनासाठी `SMTP` निवडू शकता किंवा सानुकूल धोरणे परिभाषित करू शकता.

from email.message import EmailMessage
from email import policy

msg = EmailMessage(policy=policy.SMTP)
msg['Subject'] = 'Email with Custom Header'
msg['From'] = 'info@example.org'
msg['To'] = 'user@example.org'
msg['X-Custom-Header'] = 'This is a custom value for tracking'
msg['Reply-To'] = 'support@example.org'
msg.set_content('This email demonstrates custom headers and policies.')

print(msg.as_string())

स्पष्टीकरण:

• policy=policy.SMTP वापरल्याने SMTP मानकांचे कठोर पालन सुनिश्चित होते, जे डिलिव्हरीसाठी महत्त्वपूर्ण असू शकते.
• सानुकूल हेडर मानक हेडरसारखेच जोडले जातात. ते बऱ्याचदा नॉन-स्टँडर्ड हेडर दर्शवण्यासाठी X- ने सुरू होतात.

MIME संदेश पार्सिंग: येणाऱ्या ईमेलमधून माहिती काढणे

पार्सिंगमध्ये कच्च्या ईमेल डेटाला (सामान्यतः IMAP किंवा फाइलमधून प्राप्त) `EmailMessage` ऑब्जेक्टमध्ये रूपांतरित करणे समाविष्ट आहे, ज्याची तुम्ही नंतर सहजपणे तपासणी आणि हाताळणी करू शकता.

लोडिंग आणि प्रारंभिक पार्सिंग

तुम्हाला सामान्यतः बाइट्स म्हणून ईमेल प्राप्त होतील. email.parser.BytesParser (किंवा सोयीस्कर फंक्शन्स email.message_from_bytes()) यासाठी वापरले जाते.

from email.parser import BytesParser
from email.policy import default

raw_email_bytes = b"""
From: sender@example.com
To: recipient@example.com
Subject: Test Email with Basic Headers
Date: Mon, 1 Jan 2024 10:00:00 +0000
Content-Type: text/plain; charset=\"utf-8\"\n\nThis is the body of the email.\nIt's a simple test.
"""

# BytesParser वापरून
parser = BytesParser(policy=default)
msg = parser.parsebytes(raw_email_bytes)

# किंवा सोयीस्कर फंक्शन वापरून
# from email import message_from_bytes
# msg = message_from_bytes(raw_email_bytes, policy=default)

print(f"Subject: {msg['subject']}")
print(f"From: {msg['from']}")
print(f"Content-Type: {msg['Content-Type']}")

स्पष्टीकरण:

• BytesParser कच्च्या बाइट डेटाला (ज्या प्रकारे ईमेल प्रसारित केले जातात) घेते आणि EmailMessage ऑब्जेक्ट परत करते.
• policy=default पार्सिंग नियम निर्दिष्ट करते.

हेडर ऍक्सेस करणे

डिक्शनरी-सारख्या की (keys) द्वारे हेडर सहजपणे ऍक्सेस केले जातात. पॅकेज एन्कोड केलेल्या हेडरचे (उदा. आंतरराष्ट्रीय वर्णांचे विषय) डीकोडिंग आपोआप हाताळते.

# ... (मागील पार्सिंग उदाहरणातील 'msg' ऑब्जेक्ट वापरून)

print(f"Date: {msg['date']}")
print(f"Message ID: {msg['Message-ID'] if 'Message-ID' in msg else 'N/A'}")

# अनेक हेडर हाताळणे (उदा. 'Received' हेडर)
# from email.message import EmailMessage # जर आधीच इम्पोर्ट केले नसेल
# from email import message_from_string # जलद स्ट्रिंग उदाहरणासाठी

multi_header_email = message_from_string(
    """
From: a@example.com
To: b@example.com
Subject: Multi-header Test
Received: from client.example.com (client.example.com [192.168.1.100])
        by server.example.com (Postfix) with ESMTP id 123456789
        for <b@example.com>; Mon, 1 Jan 2024 10:00:00 +0000 (GMT)
Received: from mx.another.com (mx.another.com [192.168.1.101])
        by server.example.com (Postfix) with ESMTP id 987654321
        for <b@example.com>; Mon, 1 Jan 2024 09:59:00 +0000 (GMT)

Body content here.
"""
)

received_headers = multi_header_email.get_all('received')
if received_headers:
    print("\nReceived Headers:")
    for header in received_headers:
        print(f"- {header}")

स्पष्टीकरण:

• हेडर ऍक्सेस केल्याने त्याची व्हॅल्यू स्ट्रिंग म्हणून मिळते.
• get_all('header-name') हेडरसाठी उपयुक्त आहे जे एकाधिक वेळा दिसू शकतात (उदा. Received).
• पॅकेज हेडर डीकोडिंग हाताळते, त्यामुळे Subject: =?utf-8?Q?Global_Characters:_=E3=81=93=E3=82=93=E3=81=AB=E3=81=A1=E3=81=AF?= सारख्या व्हॅल्यू वाचनीय स्ट्रिंग्समध्ये आपोआप रूपांतरित होतात.

बॉडी सामग्री एक्सट्रॅक्ट करणे

वास्तविक संदेश बॉडी एक्सट्रॅक्ट करण्यासाठी संदेश मल्टीपार्ट आहे की नाही हे तपासणे आवश्यक आहे. मल्टीपार्ट संदेशांसाठी, तुम्ही त्याच्या भागांमधून पुनरावृत्ती करता.

from email.message import EmailMessage
from email import message_from_string

multipart_email_raw = """
From: multi@example.com
To: user@example.com
Subject: Test Multipart Email
Content-Type: multipart/alternative; boundary="_----------=_12345"""

--_----------=_12345
Content-Type: text/plain; charset="utf-8"

Hello from the plain text part!

--_----------=_12345
Content-Type: text/html; charset="utf-8"

<html>
<body>
<h1>Hello from the HTML part!</h1>
<p>This is a <strong>rich text</strong> email.</p>
</body>
</html>

--_----------=_12345--
"""

msg = message_from_string(multipart_email_raw)

if msg.is_multipart():
    print("\n--- Multipart Email Body ---")
    for part in msg.iter_parts():
        content_type = part.get_content_type()
        charset = part.get_content_charset() or 'utf-8' # निर्दिष्ट नसल्यास utf-8 वर डीफॉल्ट
        payload = part.get_payload(decode=True) # पेलोड बाइट्स डीकोड करा

        try:
            decoded_content = payload.decode(charset)
            print(f"Content-Type: {content_type}, Charset: {charset}\nContent:\n{decoded_content}\n")
        except UnicodeDecodeError:
            print(f"Content-Type: {content_type}, Charset: {charset}\nContent: (Binary or undecodable data)\n")
            # बायनरी डेटा हाताळा, किंवा फॉलबॅक एन्कोडिंगचा प्रयत्न करा
else:
    print("\n--- Single Part Email Body ---")
    charset = msg.get_content_charset() or 'utf-8'
    payload = msg.get_payload(decode=True)
    try:
        decoded_content = payload.decode(charset)
        print(f"Content-Type: {msg.get_content_type()}, Charset: {charset}\nContent:\n{decoded_content}\n")
    except UnicodeDecodeError:
        print(f"Content: (Binary or undecodable data)\n")

स्पष्टीकरण:

• is_multipart() ईमेलमध्ये एकाधिक भाग आहेत की नाही हे ठरवते.
• iter_parts() मल्टीपार्ट संदेशातील सर्व सब-पार्ट्समधून पुनरावृत्ती करते.
• get_content_type() पूर्ण MIME प्रकार (उदा. text/plain) परत करते.
• get_content_charset() Content-Type हेडरमधून charset काढते.
• get_payload(decode=True) महत्त्वपूर्ण आहे: ते डीकोड केलेली सामग्री बाइट्स म्हणून परत करते. पायथन स्ट्रिंग मिळवण्यासाठी तुम्हाला या बाइट्सना योग्य charset वापरून .decode() करावे लागेल.

पार्सिंग दरम्यान संलग्नके हाताळणे

संलग्नके देखील मल्टीपार्ट संदेशाचे भाग असतात. तुम्ही त्यांचे Content-Disposition हेडर वापरून त्यांना ओळखू शकता आणि त्यांचे डीकोड केलेले पेलोड सेव्ह करू शकता.

from email.message import EmailMessage
from email import message_from_string
import os

# एका साध्या संलग्नकासह उदाहरण ईमेल
email_with_attachment = """
From: attach@example.com
To: user@example.com
Subject: Document Attached
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="_----------=_XYZ"""

--_----------=_XYZ
Content-Type: text/plain; charset="utf-8"

Here is your requested document.

--_----------=_XYZ
Content-Type: application/pdf
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="document.pdf"

JVBERi0xLjQKMSAwIG9iagpbL1BERi9UZXh0L0ltYWdlQy9JbWFnZUkvSW1hZ0VCXQplbmRvYmoK

--_----------=_XYZ--
"""

msg = message_from_string(email_with_attachment)

output_dir = 'parsed_attachments'
os.makedirs(output_dir, exist_ok=True)

print("\n--- Processing Attachments ---")
for part in msg.iter_attachments():
    filename = part.get_filename()
    if filename:
        filepath = os.path.join(output_dir, filename)
        try:
            with open(filepath, 'wb') as f:
                f.write(part.get_payload(decode=True))
            print(f"Saved attachment: {filepath} (Type: {part.get_content_type()})")
        except Exception as e:
            print(f"Error saving {filename}: {e}")
    else:
        print(f"Found an attachment without a filename (Content-Type: {part.get_content_type()})")

# आउटपुट डिरेक्टरी स्वच्छ करा
# import shutil
# shutil.rmtree(output_dir)

स्पष्टीकरण:

• iter_attachments() विशेषतः संलग्नके असण्याची शक्यता असलेले भाग (म्हणजे, Content-Disposition: attachment हेडर असलेले किंवा अन्यथा वर्गीकृत नसलेले) प्रदान करते.
• get_filename() Content-Disposition हेडरमधून फाइलचे नाव काढते.
• part.get_payload(decode=True) संलग्नकाची कच्ची बायनरी सामग्री (base64 किंवा quoted-printable मधून आधीच डीकोड केलेली) मिळवते.

एन्कोडिंग आणि कॅरेक्टर सेट्स डीकोड करणे

जेव्हा तुम्ही get_payload(decode=True) कॉल करता तेव्हा email पॅकेज सामान्य ट्रान्सफर एन्कोडिंग (उदा. base64, quoted-printable) डीकोड करण्याचे उत्कृष्ट काम करते. मजकूर सामग्रीसाठी, ते Content-Type हेडरमध्ये निर्दिष्ट केलेला charset वापरण्याचा प्रयत्न करते. जर charset निर्दिष्ट नसेल किंवा अवैध असेल, तर तुम्हाला ते व्यवस्थित हाताळावे लागेल.

from email.message import EmailMessage
from email import message_from_string

# संभाव्यतः समस्याग्रस्त charset सह उदाहरण
email_latin1 = """
From: legacy@example.com
To: new_system@example.com
Subject: Special characters: àéíóú
Content-Type: text/plain; charset="iso-8859-1"""

This message contains Latin-1 characters: àéíóú
"""

msg = message_from_string(email_latin1)

if msg.is_multipart():
    for part in msg.iter_parts():
        payload = part.get_payload(decode=True)
        charset = part.get_content_charset() or 'utf-8'
        try:
            print(f"Decoded (Charset: {charset}): {payload.decode(charset)}")
        except UnicodeDecodeError:
            print(f"Failed to decode with {charset}. Trying fallback...")
            # सामान्य charset किंवा 'latin-1' वर फॉलबॅक करा, जर अपेक्षित असेल
            print(f"Decoded (Fallback Latin-1): {payload.decode('latin-1', errors='replace')}")
else:
    payload = msg.get_payload(decode=True)
    charset = msg.get_content_charset() or 'utf-8'
    try:
        print(f"Decoded (Charset: {charset}): {payload.decode(charset)}")
    except UnicodeDecodeError:
        print(f"Failed to decode with {charset}. Trying fallback...")
        print(f"Decoded (Fallback Latin-1): {payload.decode('latin-1', errors='replace')}")

स्पष्टीकरण:

• Content-Type हेडरमध्ये निर्दिष्ट केलेला charset वापरण्याचा नेहमी प्रयत्न करा.
• UnicodeDecodeError किंवा KeyError साठी एक मजबूत try-except ब्लॉक वापरा, विशेषतः जेव्हा विविध आणि संभाव्यतः नॉन-स्टँडर्ड स्त्रोतांकडून ईमेल हाताळले जातात.
• .decode() सह errors='replace' किंवा errors='ignore' वापरले जाऊ शकतात, ज्यामुळे लक्ष्य एन्कोडिंगमध्ये मॅप न होणारे वर्ण हाताळता येतात आणि क्रॅश टाळता येतात.

प्रगत पार्सिंग परिदृश्ये

वास्तविक ईमेल अत्यंत क्लिष्ट असू शकतात, ज्यात नेस्टेड मल्टीपार्ट स्ट्रक्चर्स असतात. email पॅकेजची रिकर्सिव्ह (recursive) निसर्ग यांना सहजपणे नेव्हिगेट करण्यास मदत करते. तुम्ही डीपली नेस्टेड संदेशांना ट्रॅव्हर्स करण्यासाठी is_multipart() आणि iter_parts() एकत्र करू शकता.

from email.message import EmailMessage
from email import message_from_string

def parse_email_part(part, indent=0):
    prefix = "  " * indent
    content_type = part.get_content_type()
    charset = part.get_content_charset() or 'N/A'
    print(f"{prefix}Part Type: {content_type}, Charset: {charset}")

    if part.is_multipart():
        for subpart in part.iter_parts():
            parse_email_part(subpart, indent + 1)
    elif part.get_filename(): # हे एक संलग्नक आहे
        print(f"{prefix}  Attachment: {part.get_filename()} (Size: {len(part.get_payload(decode=True))} bytes)")
    else: # हे एक नियमित मजकूर/html बॉडी भाग आहे
        payload = part.get_payload(decode=True)
        try:
            decoded_content = payload.decode(charset)
            # print(f"{prefix}  Content (first 100 chars): {decoded_content[:100]}...") # संक्षिप्ततेसाठी
        except UnicodeDecodeError:
            print(f"{prefix}  Content: (Binary or undecodable text)")

complex_email_raw = """
From: complex@example.com
To: receiver@example.com
Subject: Complex Email with HTML, Plain, and Attachment
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="outer_boundary"""

--outer_boundary
Content-Type: multipart/alternative; boundary="inner_boundary"

--inner_boundary
Content-Type: text/plain; charset="utf-8"

Plain text content.

--inner_boundary
Content-Type: text/html; charset="utf-8"

<html><body><h2>HTML Content</h2></body></html>

--inner_boundary--

--outer_boundary
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="data.bin"

SGVsbG8gV29ybGQh

--outer_boundary--
"""

msg = message_from_string(complex_email_raw)
print("\n--- Traversing Complex Email Structure ---")
parse_email_part(msg)

स्पष्टीकरण:

• रिकर्सिव्ह फंक्शन parse_email_part हे संपूर्ण संदेश ट्रीमध्ये कसे फिरायचे, मल्टीपार्ट भाग, संलग्नके आणि बॉडी सामग्री प्रत्येक स्तरावर कशी ओळखायची हे दर्शवते.
• हे स्वरूप नेस्टेड ईमेलमधून विशिष्ट प्रकारचे सामग्री काढण्यासाठी अत्यंत लवचिक आहे.

निर्मिती वि. पार्सिंग: तुलनात्मक दृष्टिकोन

जरी भिन्न क्रिया असल्या तरी, निर्मिती आणि पार्सिंग हे एकाच नाण्याच्या दोन बाजू आहेत: MIME संदेश हाताळणे. एकाचे आकलन केल्याने दुसऱ्याला मदत होते.

निर्मिती (पाठवणे):

• लक्ष्य: हेडर, सामग्री आणि संलग्नके एका मानक-अनुरूप MIME स्ट्रक्चरमध्ये योग्यरित्या एकत्र करणे.
• प्राथमिक साधन: email.message.EmailMessage set_content(), add_attachment(), add_alternative(), add_related() सारख्या पद्धतींसह.
• मुख्य आव्हाने: योग्य MIME प्रकार, charsets (विशेषतः जागतिक समर्थनासाठी UTF-8), `Content-Transfer-Encoding`, आणि योग्य हेडर फॉरमॅटिंग सुनिश्चित करणे. चुकांमुळे ईमेल योग्यरित्या प्रदर्शित न होणे, संलग्नके दूषित होणे किंवा स्पॅम म्हणून ध्वजांकित होणे यासारख्या समस्या उद्भवू शकतात.

पार्सिंग (प्राप्त करणे):

• लक्ष्य: कच्च्या ईमेल बाइट स्ट्रीमला त्याच्या घटक भागांमध्ये विघटित करणे, विशिष्ट हेडर, बॉडी सामग्री आणि संलग्नके काढणे.
• प्राथमिक साधन: email.parser.BytesParser किंवा email.message_from_bytes(), नंतर परिणामी EmailMessage ऑब्जेक्टला is_multipart(), iter_parts(), get_payload(), get_filename(), आणि हेडर ऍक्सेस वापरून नेव्हिगेट करणे.
• मुख्य आव्हाने: चुकीचे ईमेल हाताळणे, कॅरेक्टर एन्कोडिंग ओळखणे (विशेषतः संदिग्ध असताना), गहाळ हेडरशी व्यवहार करणे, आणि विविध MIME स्ट्रक्चर्समधून डेटा मजबूतपणे काढणे.

EmailMessage वापरून तुम्ही तयार केलेला संदेश BytesParser द्वारे पूर्णपणे पार्स करण्यायोग्य असावा. त्याचप्रमाणे, पार्सिंग दरम्यान तयार केलेल्या MIME स्ट्रक्चरला समजून घेतल्याने तुम्हाला स्वतः जटिल संदेश कसे तयार करायचे याची अंतर्दृष्टी मिळते.

Python सह जागतिक ईमेल हाताळण्यासाठी सर्वोत्तम पद्धती

जागतिक प्रेक्षकांशी संवाद साधणाऱ्या किंवा विविध ईमेल स्त्रोत हाताळणाऱ्या ऍप्लिकेशन्ससाठी, या सर्वोत्तम पद्धतींचा विचार करा:

• UTF-8 वर मानकीकरण करा: सर्व मजकूर सामग्रीसाठी नेहमी UTF-8 वापरा, दोन्ही तयार करताना आणि पार्सिंग दरम्यान अपेक्षित असताना. हे कॅरेक्टर एन्कोडिंगसाठी जागतिक मानक आहे आणि मोजीबाके (गोंधळलेला मजकूर) टाळते.
• ईमेल पत्ते प्रमाणित करा: पाठवण्यापूर्वी, डिलिव्हरी सुनिश्चित करण्यासाठी प्राप्तकर्ता ईमेल पत्ते प्रमाणित करा. पार्सिंग दरम्यान, `From`, `To`, किंवा `Cc` हेडरमध्ये संभाव्यतः अवैध किंवा चुकीचे फॉरमॅट केलेले पत्ते हाताळण्यासाठी तयार रहा.
• कठोरपणे चाचणी करा: विविध ईमेल क्लायंट (Gmail, Outlook, Apple Mail, Thunderbird) आणि प्लॅटफॉर्मसह तुमच्या ईमेल निर्मितीची चाचणी करा जेणेकरून HTML आणि संलग्नकांची सातत्यपूर्ण रेंडरिंग सुनिश्चित होईल. पार्सिंगसाठी, नमुन्यांच्या ईमेलच्या विस्तृत श्रेणीसह चाचणी करा, ज्यात असामान्य एन्कोडिंग, गहाळ हेडर किंवा जटिल नेस्टेड स्ट्रक्चर्स असलेल्या ईमेलचा समावेश असेल.
• पार्स केलेल्या इनपुटचे सॅनिटाइजेशन करा: येणाऱ्या ईमेलमधून काढलेली सामग्री नेहमी अविश्वसनीय म्हणून हाताळा. जर तुम्ही वेब ऍप्लिकेशनमध्ये HTML सामग्री प्रदर्शित करत असाल तर XSS हल्ले टाळण्यासाठी ती सॅनिटाइज करा. फाइल्स सेव्ह करताना पाथ ट्रॅव्हर्सल किंवा इतर सुरक्षा भेद्यता टाळण्यासाठी संलग्नक फाइलनावे आणि प्रकार प्रमाणित करा.
• मजबूत एरर हँडलिंग: पेलोड डीकोड करताना किंवा संभाव्यतः गहाळ हेडर ऍक्सेस करताना व्यापक try-except ब्लॉक लागू करा. UnicodeDecodeError किंवा KeyError व्यवस्थित हाताळा.
• मोठ्या संलग्नकांना हाताळा: संलग्नकांच्या आकारांकडे लक्ष द्या, दोन्ही तयार करताना (मेल सर्वर मर्यादा ओलांडणे टाळण्यासाठी) आणि पार्सिंग करताना (अतिरिक्त मेमरी वापर किंवा डिस्क स्पेस वापर टाळण्यासाठी). जर तुमच्या सिस्टमद्वारे सपोर्ट केले जात असेल तर मोठ्या संलग्नकांचे स्ट्रीमिंग करण्याचा विचार करा.
• email.policy चा वापर करा: महत्त्वपूर्ण ऍप्लिकेशन्ससाठी, ईमेल मानकांचे कठोर पालन सुनिश्चित करण्यासाठी स्पष्टपणे `email.policy` (उदा. `policy.SMTP`) निवडा, जे डिलिव्हरी आणि इंटरऑपरेबिलिटीवर परिणाम करू शकते.
• मेटाडेटा जतन करणे: पार्सिंग करताना, कोणता मेटाडेटा (हेडर, मूळ बाउंड्री स्ट्रिंग) जतन करणे महत्त्वाचे आहे हे ठरवा, विशेषतः जर तुम्ही मेल आर्काइव्हल किंवा फॉरवर्डिंग सिस्टम तयार करत असाल.

निष्कर्ष

Python चे email पॅकेज हे प्रोग्रामेटिकरित्या ईमेलशी संवाद साधू इच्छिणाऱ्या कोणासाठीही एक अत्यंत शक्तिशाली आणि लवचिक लायब्ररी आहे. MIME संदेशांची निर्मिती आणि येणाऱ्या ईमेलचे मजबूत पार्सिंग या दोन्हीमध्ये प्रभुत्व मिळवून, तुम्ही उत्कृष्ट ईमेल ऑटोमेशन सिस्टम तयार करण्याची, ईमेल क्लायंट तयार करण्याची, ईमेल डेटाचे विश्लेषण करण्याची आणि जवळजवळ कोणत्याही ऍप्लिकेशनमध्ये ईमेल कार्यक्षमतेचे एकत्रीकरण करण्याची क्षमता अनलॉक करता.

हे पॅकेज MIME च्या अंतर्निहित जटिलतांचा विचारपूर्वक विचार करते, ज्यामुळे डेव्हलपर्सना त्यांच्या ईमेल संवादांच्या सामग्री आणि लॉजिकवर लक्ष केंद्रित करता येते. तुम्ही जागतिक प्रेक्षकांना वैयक्तिकृत वृत्तपत्रे पाठवत असाल किंवा स्वयंचलित सिस्टम अहवालांमधून महत्त्वपूर्ण डेटा काढत असाल, email पॅकेजचे सखोल ज्ञान तुम्हाला विश्वासार्ह, इंटरऑपरेबल आणि जागतिक स्तरावर जागरूक ईमेल सोल्यूशन्स तयार करण्यात अमूल्य ठरेल.